package Day11_2;

import java.util.Arrays;
import java.util.Comparator;

public class Sort {
    public static void bubbleSort(long[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                // 需要比较 array[j] 和 array[j + 1] 的大小
                // 由于现在 元素类型是 long 类型，基本类型，所以可以用大于、小于号比较
                if (array[j] > array[j + 1]) {
                    long t = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = t;
                }
            }
        }
    }

    public static void main1(String[] args) {
        long[] array = { 9, 5, 2, 3, 1, 4, 7, 0, 6, 8 };
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

    // 通用类型的冒泡排序 —— 泛型方法（不需要大家掌握）
    // <T> 定义一个符号 T，代表一种类型，具体是什么类型，不知道，需要调用的时候由调用者来决定
    // T 一定是一个引用类型（指向的是对象），一定不是基本类型
    // 不是基本类型，不能使用 大于号、小于号进行比较
    // 参数中没有传入 Comparator
    // 所以假定 T 一定具备了自然顺序（T 对应的类实现过 Comparable）
    public static <T> void bubbleSort(T[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                Comparable e1 = (Comparable) array[j];  // 如果 T 不是一个 Comparable，会抛异常，但是没办法了
                Comparable e2 = (Comparable) array[j + 1];

                int cmp = e1.compareTo(e2);

                if (cmp > 0) {  // array[j] > array[j + 1]
                    T t = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = t;
                }
            }
        }
    }

    // 引入传入了 Comparator，就使用 Comparator 进行比较
    public static <T> void bubbleSort(T[] array, Comparator<T> comparator) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                int cmp = comparator.compare(array[j], array[j + 1]);

                if (cmp > 0) {  // array[j] > array[j + 1]
                    T t = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = t;
                }
            }
        }
    }

    static class StudentComparator implements Comparator<Student> {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.no - o2.no;
        }
    }

    public static void main(String[] args) {
//        Integer[] array = { 9, 5, 2, 3, 1, 4, 7, 0, 6, 8 };
        Student[] array = {
                new Student(9),
                new Student(5),
                new Student(2),
                new Student(3),
                new Student(1),
                new Student(4),
                new Student(7),
                new Student(0),
                new Student(6),
                new Student(8)
        };  // Student 暂时没有自然顺序，一定抛异常

        StudentComparator c = new StudentComparator();

        // 保证类类型
        bubbleSort(array, c);
        System.out.println(Arrays.toString(array));
    }
}
